package cn.tedu.hotel.service.impl;

import cn.tedu.hotel.ex.ServiceException;
import cn.tedu.hotel.mapper.CategoryMapper;
import cn.tedu.hotel.pojo.dto.CategoryAddNewDTO;
import cn.tedu.hotel.pojo.entity.Category;
import cn.tedu.hotel.pojo.vo.CategoryListItemVO;
import cn.tedu.hotel.pojo.vo.CategoryStandardVO;
import cn.tedu.hotel.service.ICategoryService;
import cn.tedu.hotel.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

/**
 *  处理房间类型的业务实现类
 */
@Slf4j
@Service
public class CategoryServiceImpl implements ICategoryService,ServiceCode {

    @Autowired
    CategoryMapper categoryMapper;

    public CategoryServiceImpl(){
        log.debug("创建业务对象：TypeServiceImpl");
    }
    
    @Override
    public void addNew(CategoryAddNewDTO categoryAddNewDTO) {
        //日志
        log.debug("开始处理【添加房间类型】的业务，参数：{}", categoryAddNewDTO);
        //获取需要添加的房间类型名称
        String name = categoryAddNewDTO.getName();
        // 调用TypeMapper的countByName(String name)
        int count = categoryMapper.countByName(name);
        //判断返回的数据数量 是否大于0
        if (count > 0){
            // 是：日志，数据已存在 不能添加，抛出异常
            String message = "添加失败，数据已存在，不允许添加";
            log.debug(message);
            throw new ServiceException(ERR_CONFLICT,message);
        }

        //获取当前时间
        LocalDateTime now = LocalDateTime.now();
        //创建Type对象
        Category category = new Category();
        //补全Type对象的属性值
        BeanUtils.copyProperties(categoryAddNewDTO, category);
        category.setGmtCreate(now);
        category.setGmtModified(now);
        // 调用TypeMapper的insert（）方法，执行插入数据
        log.debug("即将向数据库插入房间类型数据：{}", category);
        int rows = categoryMapper.insert(category);
        // 判断返回受影响行数是否有误（是否不等于1）
        if (rows != 1){
            //是 ： 不等于1  插入失败，抛出异常
            String message = "添加失败，服务器繁忙，请稍后再试";
            log.debug(message);
            throw new ServiceException(ERR_INSERT,message);
        }
    }

    @Override
    public void deleteById(Long id) {
        //日志
        log.debug("开始处理【根据id删除房间类型】的业务，id={}",id);
        //调用TypeMapper 的getStandardById(Long id) 获取数据详情
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        //判断返回结果是否为null
        if (queryResult == null){
            // 是 ： 返回为null 表示没有该数据
            String message = "删除失败，尝试访问的数据不存在";
            log.debug(message);
            throw new ServiceException(ERR_NOT_FOUND,message);
        }

        log.debug("即将删除id={}的房间类型数据",id);
        // 调用TypeMapper 的deleteById(Long id)方法 执行删除
        int rows = categoryMapper.deleteById(id);
        // 判断返回受影响行数是否有误
        if (rows != 1){
            String message = "删除失败，服务器繁忙，请稍后再试";
            log.debug(message);
            throw new ServiceException(ERR_DELETE,message);
        }
        
    }

    @Override
    public void setEnable(Long id) {
        log.debug("开始处理【启用房间类型】的业务：id={}",id);
        // 根据id查询房间类型数据
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        // 判断是否为null
        {
            if (queryResult == null) {
                // 是：数据不存在，抛出异常
                String message = "启用失败，访问数据不存在";
                log.warn(message);
                throw new ServiceException(ERR_NOT_FOUND, message);
            }

            // 判断查询结果中的enable是否为1
            if (queryResult.getEnable() == 1) {
                // 是：状态重复，抛出异常
                String message = "启用失败，该房间类型已经是启用状态";
                log.warn(message);
                throw new ServiceException(ERR_CONFLICT, message);
            }
        }

        // 创建对象，并设置状态值
        {
            Category category = new Category();
            category.setId(id);
            category.setEnable(1);
            //执行更新，获取返回值
            int rows = categoryMapper.update(category);
            //判断返回值是否有误
            if (rows != 1) {
                String message = "启用房间类型失败，服务器繁忙，请稍后再试";
                log.warn(message);
                throw new ServiceException(ERR_UPDATE, message);
            }
        }

        // 修改房间数量
        {
            if (queryResult == null){
                String message = "房间类型不存在，无法修改";
                log.debug(message);
                throw new ServiceException(ERR_NOT_FOUND, message);
            }

            Category category = new Category();
            category.setId(id);
            category.setSurplus(queryResult.getSurplus()+1);
            categoryMapper.update(category);
        }
    }

    @Override
    public void setDisable(Long id) {
        log.debug("开始处理【禁用房间类型】的业务：id={}",id);
        // 根据id查询房间类型数据
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        {
            // 判断是否为null
            if (queryResult == null) {
                // 是：数据不存在，抛出异常
                String message = "禁用失败，访问数据不存在";
                log.warn(message);
                throw new ServiceException(ERR_NOT_FOUND, message);
            }
        }

        {
            // 判断查询结果中的enable是否为0
            if (queryResult.getEnable() == 0) {
                // 是：状态重复，抛出异常
                String message = "禁用失败，该房间类型已经是启用状态";
                log.warn(message);
                throw new ServiceException(ERR_CONFLICT, message);
            }
        }


        // 创建对象，并设置状态值
        {
            Category category = new Category();
            category.setId(id);
            category.setEnable(0);
            //执行更新，获取返回值
            int rows = categoryMapper.update(category);
            //判断返回值是否有误
            if (rows != 1) {
                String message = "禁用房间类型失败，服务器繁忙，请稍后再试";
                log.warn(message);
                throw new ServiceException(ERR_UPDATE, message);
            }
        }

        // 修改房间数量
        {
            if (queryResult == null){
                String message = "房间类型不存在，无法修改";
                log.debug(message);
                throw new ServiceException(ERR_NOT_FOUND, message);
            }

            Category category = new Category();
            category.setId(id);
            category.setSurplus(queryResult.getSurplus()-1);
            categoryMapper.update(category);
        }
    }

    @Override
    public void setIsDisplay(Long id) {
        log.debug("开始处理【设置房间类型显示在导航栏】的业务：id={}",id);
        // 根据id查询房间类型数据
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        // 判断是否为null
        if (queryResult == null){
            // 是：数据不存在，抛出异常
            String message = "设置失败，访问数据不存在";
            log.warn(message);
            throw new ServiceException(ERR_NOT_FOUND,message);
        }

        // 判断查询结果中的isDisplay是否为1
        if (queryResult.getIsDisplay() == 1){
            // 是：状态重复，抛出异常
            String message = "设置失败，该房间类型已经是启用状态";
            log.warn(message);
            throw new ServiceException(ERR_CONFLICT,message);
        }

        // 创建对象，并设置状态值
        Category category = new Category();
        category.setId(id);
        category.setIsDisplay(1);
        //执行更新，获取返回值
        int rows = categoryMapper.update(category);
        //判断返回值是否有误
        if (rows != 1){
            String message = "设置房间类型显示在导航栏失败，服务器繁忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ERR_UPDATE,message);
        }
    }

    @Override
    public void setNotDisplay(Long id) {
        log.debug("开始处理【设置房间类型不显示在导航栏】的业务：id={}",id);
        // 根据id查询房间类型数据
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        // 判断是否为null
        if (queryResult == null){
            // 是：数据不存在，抛出异常
            String message = "设置失败，访问数据不存在";
            log.warn(message);
            throw new ServiceException(ERR_NOT_FOUND,message);
        }

        // 判断查询结果中的isDisplay是否为0
        if (queryResult.getIsDisplay() == 0){
            // 是：状态重复，抛出异常
            String message = "设置失败，该房间类型已经是启用状态";
            log.warn(message);
            throw new ServiceException(ERR_CONFLICT,message);
        }

        // 创建对象，并设置状态值
        Category category = new Category();
        category.setId(id);
        category.setIsDisplay(0);
        //执行更新，获取返回值
        int rows = categoryMapper.update(category);
        //判断返回值是否有误
        if (rows != 1){
            String message = "设置房间类型不显示在导航栏失败，服务器繁忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ERR_UPDATE,message);
        }
    }


    @Override
    public List<CategoryListItemVO> listType() {
        log.debug("开始处理【查询类型列表】业务");
        return categoryMapper.listType();
    }


}
